/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package prueba3;

import DAO.DAO;
import entidades.Alarmavariable;
import entidades.Bitacora;
import entidades.Dispositivo;
import entidades.Equipos;
import entidades.Historialalarma;
import entidades.Señales;
import entidades.Valores;
import entidades.Varbd;
import entidades.VarbdPK;
import entidades.Varfd;
import entidades.VarfdPK;
import entidades.Variable;
import entidades.Varid;
import entidades.VaridPK;
import java.math.BigInteger;
import java.util.Date;

/**
 *
 * @author CAMILO SUAREZ
 */
public class Protocolo {

    private static final int MASK = 0xff;
    public int IdDispositivo = 0;
    int[] DO = new int[5];//Funcion uno
    int[] EnAT = new int[70];//Funcion uno      
    int[] EnL = new int[70];//Funcion uno
    int[] DI = new int[3];//Funcion dos
    int mDO, cDO, RESET, BACKLIGHT, GPRS_ON, SD_ON, LPinSP, ResetCin, ResetCOut, LCD_ON, ENAT_ALL, Ev_Save, Ev_Get, Learning, EnSim, EnTvar, Q_MB;//Funcion dos
    float[] ScaleMax = new float[3];//Funcion tres
    float[] ScaleMin = new float[3];//Funcion tres
    int[] strIP = new int[4];//Funcion tres
    float AO_0, Qtotal, Qdia, Dev, Kp, Ti, Td, Pxout, SP, C, theta, ypp, lambda;
    int Pmin_Mod, Qmax_Mod, Qmin_Mod, Tavg, En_Mod, Control, Controlador, Por, tm, Save, Time1, APN, Num_Pulsos, Ton, Toff, Enviar, In_Out, iTon, iToff, oTon, oToff, iNumPulsos, oNumPulsos, Pmin, Pmax, NF, N, Ns, S, GPRS_Time, SD_Time, LCD_Time, Pmax_Mod, GPRSPort, GPRSID;
    float[] AI = new float[8];//Funcion cuatro
    float[] fAI = new float[8];//Funcion cuatro
    int[] GPRSIP = new int[4];//Funcion cuatro
    float PresionIn, PresionOut, Caudal, cIn, cOut, BestValue;//Funcion cuatro
    int MemErr, GPRS_status, SD_status, tHour, tMinute, tWeek, BestMember, GPRSQuality;//Funcion cuatro
    int[] THAT = new int[70];//Funcion seis
    int[] TMAT = new int[70];//Funcion seis
    float[] SPAT = new float[70];//Funcion seis
    int[] Es = new int[70];
    Equipos disp;
    DAO dao;
    Varbd varbd;
    VarbdPK varbdpk;
    //VaridJpaController var;// esto en necesario??
    VaridPK varidpk;
    Varid varid;
    Varfd varfd;
    VarfdPK varfdpk;
    Variable variable;
    Bitacora bitacora;
    Alarmavariable alarmavariable;
    boolean banderaAlarmaHIHIPi = false;
    boolean banderaAlarmaHIPi = false;
    boolean banderaAlarmaLOLOPi = false;
    boolean banderaAlarmaLOPi = false;
    boolean banderaAlarmaHIHIPo = false;
    boolean banderaAlarmaHIPo = false;
    boolean banderaAlarmaLOLOPo = false;
    boolean banderaAlarmaLOPo = false;
    boolean banderaAlarmaHIHICaudal = false;
    boolean banderaAlarmaHICaudal = false;
    boolean banderaAlarmaLOLOCaudal = false;
    boolean banderaAlarmaLOCaudal = false;
    String nota = "i";

    public Protocolo() {
        dao = new DAO();
    }

    public void FuncionUno(byte[] b) {//verificado
        if (b.length == 196) {// comprobacion, cantidad de datos recibidos de acuerdo al protocolo si no tiene la longitud esperada se omite la informacion
            for (int i = 0; i <= 4; i++) {
                DO[i] = ByteToBoolean(b[i + 6], b[5]);
                varbd = new Varbd();
                varbdpk = new VarbdPK();
                varbdpk.setIddispositivo(IdDispositivo);
                varbdpk.setIdvariableb(i + 4);
                varbd.setVarbdPK(varbdpk);
                varbd.setDato(DO[i]);
                dao.edit(varbd);
            }
            for (int i = 0; i <= 69; i++) {
                varbd = new Varbd();
                varbdpk = new VarbdPK();
                EnAT[i] = ByteToBoolean(b[i + 56], b[5]);
                varbdpk.setIddispositivo(IdDispositivo);
                varbdpk.setIdvariableb(i + 26);
                varbd.setVarbdPK(varbdpk);
                varbd.setDato(EnAT[i]);
                dao.edit(varbd);
            }
            for (int i = 0; i <= 69; i++) {
                varbd = new Varbd();
                varbdpk = new VarbdPK();
                EnL[i] = ByteToBoolean(b[i + 126], b[5]);
                varbdpk.setIddispositivo(IdDispositivo);
                varbdpk.setIdvariableb(i + 96);
                varbd.setVarbdPK(varbdpk);
                varbd.setDato(EnL[i]);
                dao.edit(varbd);
            }
            mDO = ByteToBoolean(b[11], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(9);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(mDO);
            dao.edit(varbd);

            cDO = ByteToBoolean(b[12], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(10);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(cDO);
            dao.edit(varbd);

            RESET = ByteToBoolean(b[13], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(11);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(RESET);
            dao.edit(varbd);

            BACKLIGHT = ByteToBoolean(b[14], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(12);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(cDO);
            dao.edit(varbd);

            GPRS_ON = ByteToBoolean(b[15], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(13);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(GPRS_ON);
            dao.edit(varbd);

            SD_ON = ByteToBoolean(b[16], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(14);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(SD_ON);
            dao.edit(varbd);

            LPinSP = ByteToBoolean(b[17], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(15);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(LPinSP);
            dao.edit(varbd);

            ResetCin = ByteToBoolean(b[18], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(16);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(ResetCin);
            dao.edit(varbd);

            ResetCOut = ByteToBoolean(b[19], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(17);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(ResetCOut);
            dao.edit(varbd);

            LCD_ON = ByteToBoolean(b[20], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(18);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(LCD_ON);
            dao.edit(varbd);

            ENAT_ALL = ByteToBoolean(b[21], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(19);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(ENAT_ALL);
            dao.edit(varbd);

            Ev_Save = ByteToBoolean(b[22], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(20);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(Ev_Save);
            dao.edit(varbd);

            Ev_Get = ByteToBoolean(b[23], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(21);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(Ev_Get);
            dao.edit(varbd);

            Learning = ByteToBoolean(b[24], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(22);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(Learning);
            dao.edit(varbd);

            EnSim = ByteToBoolean(b[25], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(23);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(EnSim);
            dao.edit(varbd);

            EnTvar = ByteToBoolean(b[26], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(24);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(EnTvar);
            dao.edit(varbd);

            Q_MB = ByteToBoolean(b[27], b[5]);
            varbd = new Varbd();
            varbdpk = new VarbdPK();
            varbdpk.setIddispositivo(IdDispositivo);
            varbdpk.setIdvariableb(25);
            varbd.setVarbdPK(varbdpk);
            varbd.setDato(Q_MB);
            dao.edit(varbd);
        }
        System.out.println("Funcion 1 Terminada");
    }

    public void FuncionDos(byte[] b) {//verificada
        if (b.length == 9) {
            for (int i = 0; i <= 2; i++) {
                varbd = new Varbd();
                varbdpk = new VarbdPK();
                DI[i] = ByteToBoolean(b[i + 6], b[5]);
                varbdpk.setIddispositivo(IdDispositivo);
                varbdpk.setIdvariableb(i + 1);
                varbd.setVarbdPK(varbdpk);
                varbd.setDato(DI[i]);
                dao.edit(varbd);
            }
        }
        System.out.println("Funcion 2 Terminada");
    }

    public void FuncionTres(byte[] b) {//verificada
        if (b.length == 188) {
            byte[] conversion = {b[6], b[7], b[8], b[9]};
            AO_0 = byteArrayToFloat(conversion, b[5]);
            varfdpk = new VarfdPK(27, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(AO_0);
            dao.edit(varfd);
            byte[] conversion1 = {b[34], b[35], b[36], b[37]};
            Qtotal = byteArrayToFloat(conversion1, b[5]);
            varfdpk = new VarfdPK(23, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Qtotal);
            dao.edit(varfd);
            byte[] conversion2 = {b[38], b[39], b[40], b[41]};
            Qdia = byteArrayToFloat(conversion2, b[5]);
            varfdpk = new VarfdPK(24, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Qdia);
            dao.edit(varfd);
            byte[] conversion3 = {b[58], b[59], b[60], b[61]};
            Dev = byteArrayToFloat(conversion3, b[5]);
            varfdpk = new VarfdPK(28, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Dev);
            dao.edit(varfd);
            byte[] conversion4 = {b[62], b[63], b[64], b[65]};
            Kp = byteArrayToFloat(conversion4, b[5]);
            varfdpk = new VarfdPK(29, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Kp);
            dao.edit(varfd);
            byte[] conversion5 = {b[66], b[67], b[68], b[69]};
            Ti = byteArrayToFloat(conversion5, b[5]);
            varfdpk = new VarfdPK(30, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Ti);
            dao.edit(varfd);
            byte[] conversion6 = {b[70], b[71], b[72], b[73]};
            Td = byteArrayToFloat(conversion6, b[5]);
            varfdpk = new VarfdPK(31, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Td);
            dao.edit(varfd);
            byte[] conversion7 = {b[110], b[111], b[112], b[113]};
            ScaleMax[0] = byteArrayToFloat(conversion7, b[5]);
            varfdpk = new VarfdPK(32, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMax[0]);
            dao.edit(varfd);
            byte[] conversion8 = {b[114], b[115], b[116], b[117]};
            ScaleMax[1] = byteArrayToFloat(conversion8, b[5]);
            varfdpk = new VarfdPK(33, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMax[1]);
            dao.edit(varfd);
            byte[] conversion9 = {b[118], b[119], b[120], b[121]};
            ScaleMax[2] = byteArrayToFloat(conversion9, b[5]);
            varfdpk = new VarfdPK(34, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMax[2]);
            dao.edit(varfd);
            byte[] conversion10 = {b[122], b[123], b[124], b[125]};
            ScaleMin[0] = byteArrayToFloat(conversion10, b[5]);
            varfdpk = new VarfdPK(35, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMin[0]);
            dao.edit(varfd);
            byte[] conversion11 = {b[126], b[127], b[128], b[129]};
            ScaleMin[1] = byteArrayToFloat(conversion11, b[5]);
            varfdpk = new VarfdPK(36, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMin[1]);
            dao.edit(varfd);
            byte[] conversion12 = {b[130], b[131], b[132], b[133]};
            ScaleMin[2] = byteArrayToFloat(conversion12, b[5]);
            varfdpk = new VarfdPK(37, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ScaleMin[2]);
            dao.edit(varfd);
            byte[] conversion13 = {b[138], b[139], b[140], b[141]};
            Pxout = byteArrayToFloat(conversion13, b[5]);
            varfdpk = new VarfdPK(38, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Pxout);
            dao.edit(varfd);
            byte[] conversion14 = {b[144], b[145], b[146], b[147]};
            SP = byteArrayToFloat(conversion14, b[5]);
            varfdpk = new VarfdPK(39, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(SP);
            dao.edit(varfd);
            byte[] conversion15 = {b[154], b[155], b[156], b[157]};
            C = byteArrayToFloat(conversion15, b[5]);
            varfdpk = new VarfdPK(40, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(C);
            dao.edit(varfd);
            byte[] conversion16 = {b[162], b[163], b[164], b[165]};
            theta = byteArrayToFloat(conversion16, b[5]);
            varfdpk = new VarfdPK(25, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(theta);
            dao.edit(varfd);
            byte[] conversion17 = {b[170], b[171], b[172], b[173]};
            ypp = byteArrayToFloat(conversion17, b[5]);
            varfdpk = new VarfdPK(26, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(ypp);
            dao.edit(varfd);
            byte[] conversion18 = {b[180], b[181], b[182], b[183]};
            lambda = byteArrayToFloat(conversion18, b[5]);
            varfdpk = new VarfdPK(41, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(lambda);
            dao.edit(varfd);
            byte[] conversion19 = {b[10], b[11]};
            Save = byteArrayToInt(conversion19, b[5]);
            varidpk = new VaridPK(13, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Save);
            dao.edit(varid);
            byte[] conversion20 = {b[24], b[25]};
            Pmin_Mod = byteArrayToInt(conversion20, b[5]);
            varidpk = new VaridPK(20, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Pmin_Mod);
            dao.edit(varid);
            byte[] conversion21 = {b[26], b[27]};
            Qmax_Mod = byteArrayToInt(conversion21, b[5]);
            varidpk = new VaridPK(21, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Qmax_Mod);
            dao.edit(varid);
            byte[] conversion22 = {b[28], b[29]};
            Qmin_Mod = byteArrayToInt(conversion22, b[5]);
            varidpk = new VaridPK(22, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Qmin_Mod);
            dao.edit(varid);
            byte[] conversion23 = {b[30], b[31]};
            Tavg = byteArrayToInt(conversion23, b[5]);
            varidpk = new VaridPK(23, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Tavg);
            dao.edit(varid);
            byte[] conversion24 = {b[32], b[33]};
            En_Mod = byteArrayToInt(conversion24, b[5]);
            varidpk = new VaridPK(24, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(En_Mod);
            dao.edit(varid);
            byte[] conversion25 = {b[46], b[47]};
            Control = byteArrayToInt(conversion25, b[5]);
            varidpk = new VaridPK(25, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Control);
            dao.edit(varid);
            byte[] conversion26 = {b[48], b[49]};
            Controlador = byteArrayToInt(conversion26, b[5]);
            varidpk = new VaridPK(26, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Controlador);
            dao.edit(varid);
            byte[] conversion27 = {b[50], b[51]};
            Por = byteArrayToInt(conversion27, b[5]);
            varidpk = new VaridPK(27, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Por);
            dao.edit(varid);
            byte[] conversion28 = {b[56], b[57]};
            tm = byteArrayToInt(conversion28, b[5]);
            varidpk = new VaridPK(28, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(tm);
            dao.edit(varid);
            byte[] conversion29 = {b[74], b[75]};
            Time1 = byteArrayToInt(conversion29, b[5]);
            varidpk = new VaridPK(29, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Time1);
            dao.edit(varid);
            byte[] conversion30 = {b[12], b[13]};
            APN = byteArrayToInt(conversion30, b[5]);
            varidpk = new VaridPK(14, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(APN);
            dao.edit(varid);
            byte[] conversion31 = {b[88], b[89]};
            Num_Pulsos = byteArrayToInt(conversion31, b[5]);
            varidpk = new VaridPK(30, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Num_Pulsos);
            dao.edit(varid);
            byte[] conversion32 = {b[90], b[91]};
            Ton = byteArrayToInt(conversion32, b[5]);
            varidpk = new VaridPK(31, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Ton);
            dao.edit(varid);
            byte[] conversion33 = {b[92], b[93]};
            Toff = byteArrayToInt(conversion33, b[5]);
            varidpk = new VaridPK(32, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Toff);
            dao.edit(varid);
            byte[] conversion34 = {b[94], b[95]};
            Enviar = byteArrayToInt(conversion34, b[5]);
            varidpk = new VaridPK(33, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Enviar);
            dao.edit(varid);
            byte[] conversion35 = {b[96], b[97]};
            In_Out = byteArrayToInt(conversion35, b[5]);
            varidpk = new VaridPK(34, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(In_Out);
            dao.edit(varid);
            byte[] conversion36 = {b[98], b[99]};
            iTon = byteArrayToInt(conversion36, b[5]);
            varidpk = new VaridPK(35, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(iTon);
            dao.edit(varid);
            byte[] conversion37 = {b[100], b[101]};
            iToff = byteArrayToInt(conversion37, b[5]);
            varidpk = new VaridPK(36, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(iToff);
            dao.edit(varid);
            byte[] conversion38 = {b[102], b[103]};
            oTon = byteArrayToInt(conversion38, b[5]);
            varidpk = new VaridPK(37, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(oTon);
            dao.edit(varid);
            byte[] conversion39 = {b[14], b[15]};
            strIP[0] = byteArrayToInt(conversion39, b[5]);
            varidpk = new VaridPK(15, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(strIP[0]);
            dao.edit(varid);
            byte[] conversion43 = {b[16], b[17]};
            strIP[1] = byteArrayToInt(conversion43, b[5]);
            varidpk = new VaridPK(16, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(strIP[1]);
            dao.edit(varid);
            byte[] conversion47 = {b[18], b[19]};
            strIP[2] = byteArrayToInt(conversion47, b[5]);
            varidpk = new VaridPK(17, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(strIP[2]);
            dao.edit(varid);
            byte[] conversion51 = {b[20], b[21]};
            strIP[3] = byteArrayToInt(conversion51, b[5]);
            varidpk = new VaridPK(18, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(strIP[3]);
            dao.edit(varid);
            byte[] conversion40 = {b[104], b[105]};
            oToff = byteArrayToInt(conversion40, b[5]);
            varidpk = new VaridPK(38, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(oToff);
            dao.edit(varid);
            byte[] conversion41 = {b[106], b[107]};
            iNumPulsos = byteArrayToInt(conversion41, b[5]);
            varidpk = new VaridPK(39, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(iNumPulsos);
            dao.edit(varid);
            byte[] conversion42 = {b[108], b[109]};
            oNumPulsos = byteArrayToInt(conversion42, b[5]);
            varidpk = new VaridPK(40, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(oNumPulsos);
            dao.edit(varid);
            byte[] conversion44 = {b[134], b[135]};
            Pmin = byteArrayToInt(conversion44, b[5]);
            varidpk = new VaridPK(41, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Pmin);
            dao.edit(varid);
            byte[] conversion45 = {b[136], b[137]};
            Pmax = byteArrayToInt(conversion45, b[5]);
            varidpk = new VaridPK(42, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Pmax);
            dao.edit(varid);
            byte[] conversion46 = {b[142], b[143]};
            NF = byteArrayToInt(conversion46, b[5]);
            varidpk = new VaridPK(43, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(NF);
            dao.edit(varid);
            byte[] conversion48 = {b[148], b[149]};
            N = byteArrayToInt(conversion48, b[5]);
            varidpk = new VaridPK(44, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(N);
            dao.edit(varid);
            byte[] conversion49 = {b[150], b[151]};
            Ns = byteArrayToInt(conversion49, b[5]);
            varidpk = new VaridPK(45, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Ns);
            dao.edit(varid);
            byte[] conversion50 = {b[152], b[153]};
            S = byteArrayToInt(conversion50, b[5]);
            varidpk = new VaridPK(46, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(S);
            dao.edit(varid);
            byte[] conversion52 = {b[174], b[175]};
            GPRS_Time = byteArrayToInt(conversion52, b[5]);
            varidpk = new VaridPK(47, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(GPRS_Time);
            dao.edit(varid);
            byte[] conversion53 = {b[176], b[177]};
            SD_Time = byteArrayToInt(conversion53, b[5]);
            varidpk = new VaridPK(48, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(SD_Time);
            dao.edit(varid);
            byte[] conversion54 = {b[178], b[179]};
            LCD_Time = byteArrayToInt(conversion54, b[5]);
            varidpk = new VaridPK(49, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(LCD_Time);
            dao.edit(varid);
            byte[] conversion55 = {b[22], b[23]};
            Pmax_Mod = byteArrayToInt(conversion55, b[5]);
            varidpk = new VaridPK(19, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(Pmax_Mod);
            dao.edit(varid);
            byte[] conversion56 = {b[184], b[185]};
            GPRSPort = byteArrayToInt(conversion56, b[5]);// podria cambiar la funcion de conversion. actidad de puertos supera el numero dado por un entero
            varidpk = new VaridPK(50, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(GPRSPort);
            dao.edit(varid);
            byte[] conversion57 = {b[186], b[187]};
            GPRSID = byteArrayToInt(conversion57, b[5]);
            varidpk = new VaridPK(51, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(GPRSID);
            dao.edit(varid);
        }
        System.out.println("Funcion 3 Terminada");
    }

    public void FuncionCuatro(byte[] b) {//verificada
        if (b.length == 118) {
            for (int i = 0; i <= 7; i++) {
                byte[] conversion = {b[6 + i * 4], b[7 + i * 4], b[8 + i * 4], b[9 + i * 4]};
                AI[i] = byteArrayToFloat(conversion, b[5]);
                varfdpk = new VarfdPK(i + 1, IdDispositivo);
                varfd = new Varfd(varfdpk);
                varfd.setDato(AI[i]);
                dao.edit(varfd);
            }

            for (int i = 0; i <= 7; i++) {
                byte[] conversion = {b[50 + i * 4], b[51 + i * 4], b[52 + i * 4], b[53 + i * 4]};
                fAI[i] = byteArrayToFloat(conversion, b[5]);
                varfdpk = new VarfdPK(i + 12, IdDispositivo);
                varfd = new Varfd(varfdpk);
                varfd.setDato(fAI[i]);
                dao.edit(varfd);
            }
            for (int i = 0; i <= 3; i++) {
                byte[] conversion = {b[110 + i * 2], b[111 + i * 2]};
                GPRSIP[i] = byteArrayToInt(conversion, b[5]);
                varidpk = new VaridPK(i + 9, IdDispositivo);
                varid = new Varid(varidpk);
                varid.setDato(GPRSIP[i]);
                dao.edit(varid);
            }
            byte[] conversion = {b[38], b[39], b[40], b[41]};
            PresionIn = byteArrayToFloat(conversion, b[5]);
            varfdpk = new VarfdPK(9, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(PresionIn);
            dao.edit(varfd);

            byte[] conversion1 = {b[42], b[43], b[44], b[45]};
            PresionOut = byteArrayToFloat(conversion1, b[5]);
            varfdpk = new VarfdPK(10, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(PresionOut);
            dao.edit(varfd);

            byte[] conversion2 = {b[46], b[47], b[48], b[49]};
            Caudal = byteArrayToFloat(conversion2, b[5]);
            varfdpk = new VarfdPK(1, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(Caudal);
            dao.edit(varfd);

            byte[] conversion3 = {b[88], b[89], b[90], b[91]};
            cIn = byteArrayToFloat(conversion3, b[5]);
            varfdpk = new VarfdPK(20, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(cIn);
            dao.edit(varfd);

            byte[] conversion4 = {b[92], b[93], b[94], b[95]};
            cOut = byteArrayToFloat(conversion4, b[5]);
            varfdpk = new VarfdPK(21, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(cOut);
            dao.edit(varfd);

            byte[] conversion5 = {b[104], b[105], b[106], b[107]};
            BestValue = byteArrayToFloat(conversion5, b[5]);
            varfdpk = new VarfdPK(22, IdDispositivo);
            varfd = new Varfd(varfdpk);
            varfd.setDato(BestValue);
            dao.edit(varfd);
//ArrayToInt

            byte[] conversion6 = {b[82], b[83]};
            MemErr = byteArrayToInt(conversion6, b[5]);
            varidpk = new VaridPK(1, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(MemErr);
            dao.edit(varid);

            byte[] conversion7 = {b[84], b[85]};
            GPRS_status = byteArrayToInt(conversion7, b[5]);
            varidpk = new VaridPK(2, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(GPRS_status);
            dao.edit(varid);

            byte[] conversion8 = {b[86], b[87]};
            SD_status = byteArrayToInt(conversion8, b[5]);
            varidpk = new VaridPK(3, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(SD_status);
            dao.edit(varid);

            byte[] conversion9 = {b[96], b[97]};
            tHour = byteArrayToInt(conversion9, b[5]);
            varidpk = new VaridPK(4, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(tHour);
            dao.edit(varid);

            byte[] conversion10 = {b[98], b[99]};
            tMinute = byteArrayToInt(conversion10, b[5]);
            varidpk = new VaridPK(5, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(tMinute);
            dao.edit(varid);

            byte[] conversion11 = {b[100], b[101]};
            tWeek = byteArrayToInt(conversion11, b[5]);
            varidpk = new VaridPK(6, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(tWeek);
            dao.edit(varid);

            byte[] conversion12 = {b[102], b[103]};
            BestMember = byteArrayToInt(conversion12, b[5]);
            varidpk = new VaridPK(7, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(BestMember);
            dao.edit(varid);

            byte[] conversion13 = {b[108], b[109]};
            GPRSQuality = byteArrayToInt(conversion13, b[5]);
            varidpk = new VaridPK(8, IdDispositivo);
            varid = new Varid(varidpk);
            varid.setDato(GPRSQuality);
            dao.edit(varid);
        }
        System.out.println("Funcion 4 Terminada");
    }

    public void FuncionCinco(byte[] tramaDeBytes) {//verficada
        int longitudTrama = tramaDeBytes.length;
        byte nullCode = tramaDeBytes[5];
        int idSenal;
        int numeroVariablesDispositivo = dao.numeroVariablesEquipo(IdDispositivo);
        int numeroVariablesTrama = (longitudTrama - 6) / 4;
        Valores valoresRegistrar = new Valores();
        System.out.println("variables dispositivo: " + numeroVariablesDispositivo);
        System.out.println("longitudTrama: " + longitudTrama);
        System.out.println("numeroVariablesTrama: " + numeroVariablesTrama);
        System.out.println("numeroVariablesDispositivo: " + numeroVariablesDispositivo);
        // Se valida que desde el byte 6 en adelante, lo que se va a recibir
        // es multiplo de 4, debido a que para obtener cada variable float
        // se requieren 4 bytes.
        if (((longitudTrama - 6) % 4 == 0) && (numeroVariablesTrama == numeroVariablesDispositivo)) {
            // Se va a recorrer desde la primera trama de 4 bytes que arranca
            // en el byte 6 de la trama
            System.out.println("Entre!");
            idSenal = 0;
            
            for (int i = 6; i <= longitudTrama - 4; i = i + 4) {
                idSenal = idSenal + 1;
                byte[] conversion = {tramaDeBytes[i], tramaDeBytes[i + 1], tramaDeBytes[i + 2], tramaDeBytes[i + 3]};
                valoresRegistrar.setValor(byteArrayToFloat(conversion, nullCode));
                valoresRegistrar.setFecha(new Date());
                valoresRegistrar.setSeñales(new Señales(IdDispositivo, idSenal));
                dao.create(valoresRegistrar);
            }
            disp = (Equipos) dao.findObject(IdDispositivo, new Equipos());
        }
        System.out.println("Funcion 5 Terminada");
    }

    public void FuncionSeis(byte[] b) {//verificada
        if (b.length == 566) {
            for (int i = 0; i <= 69; i++) {
                byte[] conversion = {b[6 + i * 2], b[7 + i * 2]};
                THAT[i] = byteArrayToInt(conversion, b[5]);
                varidpk = new VaridPK(i + 52, IdDispositivo);
                varid = new Varid(varidpk);
                varid.setDato(THAT[i]);
                dao.edit(varid);
            }
            for (int i = 0; i <= 69; i++) {
                byte[] conversion = {b[146 + i * 2], b[147 + i * 2]};
                TMAT[i] = byteArrayToInt(conversion, b[5]);
                varidpk = new VaridPK(i + 122, IdDispositivo);
                varid = new Varid(varidpk);
                varid.setDato(TMAT[i]);
                dao.edit(varid);
            }

            for (int i = 0; i <= 69; i++) {//Posible error
                byte[] conversion = {b[286 + i * 4], b[287 + i * 4], b[288 + i * 4], b[289 + i * 4]};
                SPAT[i] = byteArrayToFloat(conversion, b[5]);
                varfdpk = new VarfdPK(i + 42, IdDispositivo);
                varfd = new Varfd(varfdpk);
                varfd.setDato(SPAT[i]);
                dao.edit(varfd);
            }
        }
        System.out.println("Funcion seis Terminada");
    }

    public void FuncionSiete(byte[] b) {//verificado
        if (b.length == 526) {
            for (int i = 0; i < 70; i++) {
                byte[] conversion = {b[i * 2 + 126], b[i * 2 + 127]};//corregido
                Es[i] = byteArrayToInt(conversion, b[5]);
                varidpk = new VaridPK(i + 192, IdDispositivo);
                varid = new Varid(varidpk);
                varid.setDato(Es[i]);
                dao.edit(varid);
            }
            System.out.println("Funcion siete terminada");

        }
    }

    public byte[] FuncionDiezEnv(byte Id) {
        byte[] b = new byte[196];
        b[0] = Id;
        b[1] = 10;
        b[2] = 0;
        b[3] = -66;//22;
        b[4] = 0;//estaba en -2
        b[5] = 0;//estaba en -2
        for (int i = 0; i <= 21; i++) {
            varbdpk = new VarbdPK(IdDispositivo, i + 4);
            varbd = (Varbd) dao.findObjectByParejaPK(varbdpk, new Varbd());
            b[i + 6] = IntToByte(varbd.getDato(), b[5]);
        }
        for (int i = 0; i <= 27; i++) {
            b[i + 28] = 0;
        }
        for (int i = 0; i <= 139; i++) {
            varbdpk = new VarbdPK(IdDispositivo, i + 26);
            varbd = (Varbd) dao.findObjectByParejaPK(varbdpk, new Varbd());
            b[i + 56] = IntToByte(varbd.getDato(), b[5]);
        }

        return b;
    }

    public byte[] FuncionDiezEnv2(byte Id) {
        byte[] b = new byte[146];
        b[0] = Id;
        b[1] = 10;
        b[2] = 0;
        b[3] = -116;
        b[4] = 50;//estaba en -2
        b[5] = 0;//estaba en -2
        for (int i = 0; i <= 139; i++) {
            varbdpk = new VarbdPK(IdDispositivo, i + 26);
            varbd = (Varbd) dao.findObjectByParejaPK(varbdpk, new Varbd());
            b[i + 6] = IntToByte(varbd.getDato(), b[5]);
        }
        return b;
    }

    public byte[] FuncionOnceEnv(byte Id) {// enviar tambien el gprs time a
        byte[] b = new byte[188];
        b[0] = Id;
        b[1] = 11;
        b[2] = 0;
        b[3] = -74;
        b[4] = 0;// null code como cero
        b[5] = 0;
        //A0
        varfdpk = new VarfdPK(27, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        byte[] c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[6] = c[0];
        b[7] = c[1];
        b[8] = c[2];
        b[9] = c[3];
        //Save
        varidpk = new VaridPK(13, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[10] = c[0];
        b[11] = c[1];
        //APN
        varidpk = new VaridPK(14, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[12] = c[0];
        b[13] = c[1];
        //strip
        varidpk = new VaridPK(15, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[14] = c[0];
        b[15] = c[1];
        varidpk = new VaridPK(16, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[16] = c[0];
        b[17] = c[1];
        varidpk = new VaridPK(17, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[18] = c[0];
        b[19] = c[1];
        varidpk = new VaridPK(18, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[20] = c[0];
        b[21] = c[1];
        //pmax_mod
        varidpk = new VaridPK(19, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[22] = c[0];
        b[23] = c[1];
        //pminmod
        varidpk = new VaridPK(20, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[24] = c[0];
        b[25] = c[1];
        //qmaxmode
        varidpk = new VaridPK(21, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[26] = c[0];
        b[27] = c[1];
        //qminmod
        varidpk = new VaridPK(22, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[28] = c[0];
        b[29] = c[1];
        //Tavg
        varidpk = new VaridPK(23, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[30] = c[0];
        b[31] = c[1];
        //enmod
        varidpk = new VaridPK(24, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[32] = c[0];
        b[33] = c[1];
        //Qtotal como es de lectura no importa el valor que se especifique
        b[34] = -55;
        b[35] = 110;
        b[36] = 63;
        b[37] = -46;
        //Qdia como es de lectura no importa el valor que se especifique
        b[38] = 0;//nullcode
        b[39] = 0;
        b[40] = 0;
        b[41] = 0;
        //
        b[42] = 0;
        b[43] = 0;
        b[44] = 0;
        b[45] = 0;
        //control
        varidpk = new VaridPK(25, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[46] = c[0];
        b[47] = c[1];
        //controlador
        varidpk = new VaridPK(26, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[48] = c[0];
        b[49] = c[1];
        //por
        varidpk = new VaridPK(27, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[50] = c[0];
        b[51] = c[1];
        //
        b[52] = 0;
        b[53] = 0;
        b[54] = 0;
        b[55] = 0;
        //tm
        varidpk = new VaridPK(28, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[56] = c[0];
        b[57] = c[1];
        //Dev
        varfdpk = new VarfdPK(28, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[58] = c[0];
        b[59] = c[1];
        b[60] = c[2];
        b[61] = c[3];
        //kp
        varfdpk = new VarfdPK(29, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[62] = c[0];
        b[63] = c[1];
        b[64] = c[2];
        b[65] = c[3];
        //ti
        varfdpk = new VarfdPK(30, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[66] = c[0];
        b[67] = c[1];
        b[68] = c[2];
        b[69] = c[3];
        //td
        varfdpk = new VarfdPK(31, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[70] = c[0];//70
        b[71] = c[1];
        b[72] = c[2];
        b[73] = c[3];
        //Time1
        varidpk = new VaridPK(29, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[75] = c[0];
        b[75] = c[1];
        //
        b[76] = 0;
        b[77] = 0;
        b[78] = 0;
        b[79] = 0;
        b[80] = 0;
        b[81] = 0;
        b[82] = 0;
        b[83] = 0;
        b[84] = 0;
        b[85] = 0;
        b[86] = 0;
        b[87] = 0;
        //Num_Pulsos
        varidpk = new VaridPK(30, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[88] = c[0];
        b[89] = c[1];
        //Ton
        varidpk = new VaridPK(31, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[90] = c[0];
        b[91] = c[1];
        //Toff
        varidpk = new VaridPK(32, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[92] = c[0];
        b[93] = c[1];
        //Enviar
        varidpk = new VaridPK(33, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[94] = c[0];
        b[95] = c[1];
        //In_Out
        varidpk = new VaridPK(34, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[96] = c[0];
        b[97] = c[1];
        //iTon
        varidpk = new VaridPK(35, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[98] = c[0];
        b[99] = c[1];
        //iToff
        varidpk = new VaridPK(36, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[100] = c[0];
        b[101] = c[1];
        //oTon
        varidpk = new VaridPK(37, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[102] = c[0];
        b[103] = c[1];
        //oToff
        varidpk = new VaridPK(38, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[104] = c[0];
        b[105] = c[1];
        //iNumPulsos
        varidpk = new VaridPK(29, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[106] = c[0];
        b[107] = c[1];
        //oNumPulsos
        varidpk = new VaridPK(40, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[108] = c[0];
        b[109] = c[1];
        //ScaleMax[0]
        varfdpk = new VarfdPK(32, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[110] = c[0];
        b[111] = c[1];
        b[112] = c[2];
        b[113] = c[3];
        //ScaleMax[1]
        varfdpk = new VarfdPK(33, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[114] = c[0];
        b[115] = c[1];
        b[116] = c[2];
        b[117] = c[3];
        //ScaleMax[2]
        varfdpk = new VarfdPK(34, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[118] = c[0];
        b[119] = c[1];
        b[120] = c[2];
        b[121] = c[3];
        //ScaleMin[0]
        varfdpk = new VarfdPK(35, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[122] = c[0];
        b[123] = c[1];
        b[124] = c[2];
        b[125] = c[3];
        //ScaleMin[1]
        varfdpk = new VarfdPK(36, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[126] = c[0];
        b[127] = c[1];
        b[128] = c[2];
        b[129] = c[3];
        //ScaleMin[2]
        varfdpk = new VarfdPK(37, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[130] = c[0];
        b[131] = c[1];
        b[132] = c[2];
        b[133] = c[3];
//Pmin
        varidpk = new VaridPK(41, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[134] = c[0];// si se puede escribir este valor va a quedar en cero
        b[135] = c[1];
//Pmax
        varidpk = new VaridPK(42, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[136] = c[0];
        b[137] = c[1];
//Pxout
        varfdpk = new VarfdPK(38, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[138] = c[0];
        b[139] = c[1];
        b[140] = c[2];
        b[141] = c[3];
//NF
        varidpk = new VaridPK(43, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[142] = c[0];
        b[143] = c[1];

//SP
        varfdpk = new VarfdPK(39, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[144] = c[0];
        b[145] = c[1];
        b[146] = c[2];
        b[147] = c[3];
//N
        varidpk = new VaridPK(44, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[148] = c[0];
        b[149] = c[1];
//Ns
        varidpk = new VaridPK(45, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[150] = c[0];
        b[151] = c[1];
//S
        varidpk = new VaridPK(46, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[152] = c[0];
        b[153] = c[1];

//C
        varfdpk = new VarfdPK(40, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[154] = c[0];
        b[155] = c[1];
        b[156] = c[2];
        b[157] = c[3];
//
        b[158] = -2;
        b[159] = -2;
        b[160] = -2;
        b[161] = -2;
//theta
        varfdpk = new VarfdPK(25, IdDispositivo);// llave ojo que esta variable es de lectura unicamente
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[162] = c[0];
        b[163] = c[1];
        b[164] = c[2];
        b[165] = c[3];
//
        b[166] = 0;
        b[167] = 0;
        b[168] = 0;
        b[169] = 0;
//ypp
        varfdpk = new VarfdPK(26, IdDispositivo);// llave ojo que esta variable es de lectura unicamente
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[170] = c[0];
        b[171] = c[1];
        b[172] = c[2];
        b[173] = c[3];
//GPRS_Time
        varidpk = new VaridPK(47, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        GPRS_Time = varid.getDato();
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[174] = c[0];
        b[175] = c[1];
//SD_Time
        varidpk = new VaridPK(48, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[176] = c[0];
        b[177] = c[1];
//LCD_Time
        varidpk = new VaridPK(49, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[178] = c[0];
        b[179] = c[1];
//lambda
        varfdpk = new VarfdPK(41, IdDispositivo);// llave
        varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
        c = new byte[4];
        c = floatToByteArray(varfd.getDato());
        b[180] = c[0];
        b[181] = c[1];
        b[182] = c[2];
        b[183] = c[3];
//GPRSPort
        varidpk = new VaridPK(50, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[184] = c[0];
        b[185] = c[1];

//GPRSID
        varidpk = new VaridPK(51, IdDispositivo);
        varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
        c = new byte[2];
        c = shortToByteArray(varid.getDato());
        b[186] = c[0];
        b[187] = c[1];
        return b;
    }

    public byte[] FuncionDoceEnv(byte Id) {//averiguar la longitud real de la funcion
        byte[] b = new byte[286];
        byte[] c;
        b[0] = Id;
        b[1] = 12;
        b[2] = 0;
        b[3] = -116;
        b[4] = 0;
        b[5] = 0;
        for (int i = 0; i < 70; i++) {
            varidpk = new VaridPK(52 + i, IdDispositivo);
            varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
            c = new byte[2];
            c = shortToByteArray(varid.getDato());
            b[i * 2 + 6] = c[0];
            b[i * 2 + 7] = c[1];
        }
        for (int i = 0; i < 70; i++) {
            varidpk = new VaridPK(122 + i, IdDispositivo);
            varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
            c = new byte[2];
            c = shortToByteArray(varid.getDato());
            b[i * 2 + 146] = c[0];
            b[i * 2 + 147] = c[1];
        }

        return b;
    }

    public byte[] FuncionTreceEnv(byte Id) {//averiguar la longitud real de la funcion
        byte[] b = new byte[286];
        byte[] c;
        b[0] = Id;
        b[1] = 13;
        b[2] = 0;
        b[3] = -116;
        b[4] = 0;
        b[5] = 0;
        for (int i = 0; i < 70; i++) {
            varfdpk = new VarfdPK(42 + i, IdDispositivo);// llave
            varfd = (Varfd) dao.findObjectByParejaPK(varfdpk, new Varfd());
            c = new byte[4];
            c = floatToByteArray(varfd.getDato());
            b[6 + i * 4] = c[0];
            b[7 + i * 4] = c[1];
            b[8 + i * 4] = c[2];
            b[9 + i * 4] = c[3];
        }

        return b;
    }

    public byte[] FuncionCatorceEnv(byte Id) {
        byte[] b = new byte[146];
        byte[] c;
        b[0] = Id;
        b[1] = 14;
        b[2] = 0;
        b[3] = 70; //de acuerdo al codigo
        b[4] = 0;
        b[5] = 0;
        for (int i = 0; i < 70; i++) {
            varidpk = new VaridPK(192 + i, IdDispositivo);
            varid = (Varid) dao.findObjectByParejaPK(varidpk, new Varid());
            c = new byte[2];
            c = shortToByteArray(varid.getDato());
            b[i * 2 + 6] = c[0];
            b[i * 2 + 7] = c[1];
        }
        return b;
    }

    //Funcion para sincronizar archivos del dispositivo; se comentarea...
//    public byte[] FuncionVeinteEnv(byte Id) {
//        //obtener los numeros de la WEB y convertirlos
//        disp = (Equipos) dao.findObject(IdDispositivo, new Equipos());
//        Date fecha = disp.getFechasinc();
//        int anio1 = (fecha.getYear() - 100);
//        int anio2 = anio1 % 10;
//        int auxm = 0;
//        int auxd = 0;
//
//        anio1 = anio1 / 10;
//        int mes2 = 0;
//        int dia2 = 0;
//        int mes1 = fecha.getMonth() + 1;
//
//        if (mes1 >= 10) {
//            auxm = mes1;
//            mes1 = mes1 / 10;
//            mes2 = auxm % 10;
//        }
//        int dia1 = fecha.getDate();
//        System.out.println("Dia 1 antes de conv: " + dia1);
//        if (dia1 >= 10) {
//            auxd = dia1;
//            dia1 = dia1 / 10;
//            dia2 = auxd % 10;
//        }
//
//        boolean f = false;
//        boolean g = false;
//        boolean h = false;
//
//        byte[] b = new byte[23];
//        b[0] = Id;
//        b[1] = 20;
//        b[2] = 50;
//        b[3] = 48;
//        b[4] = (byte) (anio1 + 48);
//        b[5] = (byte) (anio2 + 48);//año2
//        b[6] = 95;//"_"
//        b[7] = 0;//mes1
//        if (mes2 >= 0 && auxm >= 10) {
//            b[8] = 0;//mes2
//            b[9] = 92;//"/"
//            // Inicio conversion de fechas
//            b[10] = (byte) (anio1 + 48); //año
//            b[11] = (byte) (anio2 + 48); //año
//            b[12] = (byte) (mes1 + 48);
//            b[13] = (byte) (mes2 + 48);
//            b[14] = (byte) (dia1 + 48);
//            b[7] = b[12];//mes1
//            b[8] = b[13];//mes2
//            if (dia2 >= 0 && auxd > 0) {
//                b[15] = (byte) (dia2 + 48);
//                b[16] = 46;
//                b[17] = 116;
//                b[18] = 120;
//                b[19] = 116;
//                b[20] = 45;
//                f = true;
//            } else {
//                b[15] = 46;
//                b[16] = 116;
//                b[17] = 120;
//                b[18] = 116;
//                b[19] = 45;
//                g = true;
//            }
//
//        } else {
//            b[8] = 92;
//            b[9] = (byte) (anio1 + 48);
//            b[10] = (byte) (anio2 + 48);
//            b[11] = (byte) (mes1 + 48);
//            b[7] = b[11];
//            if (dia2 >= 0 && auxd > 0) {
//                b[12] = (byte) (dia1 + 48);
//                b[13] = (byte) (dia2 + 48);
//                b[14] = 46;
//                b[15] = 116;
//                b[16] = 120;
//                b[17] = 116;
//                b[18] = 45;
//                h = true;
//            } else {
//                b[12] = (byte) (dia1 + 48);
//                b[13] = 46;
//                b[14] = 116;
//                b[15] = 120;
//                b[16] = 116;
//                b[17] = 45;
//            }
//
//        }
//        if (f == true) {
//            byte[] bufferAjustado3 = new byte[21];
//            System.arraycopy(b, 0, bufferAjustado3, 0, 21);
//            nota = new String(bufferAjustado3);
//            System.out.println(nota);
//            return bufferAjustado3;
//        } else {
//            if (g == true) {
//                byte[] bufferAjustado3 = new byte[20];
//                System.arraycopy(b, 0, bufferAjustado3, 0, 20);
//                nota = new String(bufferAjustado3);
//                System.out.println(nota);
//                return bufferAjustado3;
//            } else {
//                if (h == true) {
//                    byte[] bufferAjustado3 = new byte[19];
//                    System.arraycopy(b, 0, bufferAjustado3, 0, 19);
//                    nota = new String(bufferAjustado3);
//                    System.out.println(nota);
//                    return bufferAjustado3;
//                } else {
//                    byte[] bufferAjustado3 = new byte[18];
//                    System.arraycopy(b, 0, bufferAjustado3, 0, 18);
//                    nota = new String(bufferAjustado3);
//                    System.out.println(nota);
//                    return bufferAjustado3;
//                }
//            }
//        }
//    }

    public byte[] FuncionVeintiunoEnv(byte Id) {
        byte[] b = new byte[2];
        b[0] = Id;
        b[1] = 21;
        return b;
    }

    public Dispositivo FuncionVeintidos(long Identification) {
        Dispositivo dis = (Dispositivo) dao.findObject(Identification, new Dispositivo());
        return dis;
    }

    //Funcion que tambien es para el manejo de archivos
//    public byte[] FuncionVeintidosEnv(byte Id) {
//        byte[] b = new byte[2];
//        b[0] = Id;
//        b[1] = 22;
//
//        disp = (Dispositivo) dao.findObject(disp.getIddispositivo(), new Dispositivo());
//        ManejoArchivo prueba = new ManejoArchivo(disp);
//        prueba.captutarDatos(disp.getIddispositivo() + ".txt");
//
//        return b;
//    }

    public int IdentificarFuncion(byte[] b) {
        byte funcion = b[1];
        return new Integer(funcion);
        // se debe identificar apartir de la trama de bytes recibidos de que funcion se trata tomar las acciones pertinentes
    }

    public int ObtenerId(byte[] trama) {
        int a = new Integer(trama[0]);
        int b = new Integer(trama[1]);
        if (a <= 255 && a > 0 && b <= 22 && b > 0) {//Maximo 255 equipos y el segundo item de comprobacion es el numero de funcion hasta 22
            return a;
        } else {
            return 0;
        }
    }

    public boolean IdentificarBD(int ID) {
        
        disp = (Equipos) dao.findObject(new Integer(String.valueOf(ID)), new Equipos());
        if (disp != null) {
            IdDispositivo = disp.getId();
            return true;
        } else {
            return false;
        }
    }

    
    public int getTimeOut() {
        //consultar la base de datos para saber el timeOut.
        int timeout;
        try {
            //Se deja por defecto un timeout de 30 segundos para cuando 
            //el dispositivo no responde
            timeout = 30000;
        } catch (Exception e) {
            timeout = 0;
        }
        return timeout;
    }

    public int booleanToInteger(boolean dato) {
        if (dato) {
            return 1;
        } else {
            return 0;
        }
    }

    
    public int verificarComandos() {
        //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
        //return disp.getComando();
        return 0;
    }

    public void terminarComando() {
       // disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
        //disp.setComando(0);
        //dao.edit(disp);
    }

    public void setComando() {
//        disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
//        disp.setComando(21);
//        dao.edit(disp);
    }

    public void setComandod() {
//        disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
//        disp.setComando(22);
//        dao.edit(disp);
    }

    public void RegistarBitacoraConexion() {
//        bitacora = new Bitacora();
//        bitacora.setIddispositivo(BigInteger.valueOf(IdDispositivo));
//        bitacora.setNombredispositivo(disp.getNombre());
//        bitacora.setUbicacion(disp.getUbicacion());
//        bitacora.setFecha(new Date());
//        bitacora.setEvento("Conexión");
//        dao.create(bitacora);
    }

    public void RegistarBitacoraDesconexion() {
//        bitacora = new Bitacora();
//        bitacora.setIddispositivo(BigInteger.valueOf(IdDispositivo));
//        bitacora.setNombredispositivo(disp.getNombre());
//        bitacora.setUbicacion(disp.getUbicacion());
//        bitacora.setFecha(new Date());
//        bitacora.setEvento("Desconexión");
//        dao.create(bitacora);
    }

    //public void setNumCon(int num) {
    //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
    //disp.setD1(num);
    //dao.edit(disp);
    //}
    //public void rest(int Id) {
    //int num=numeroConexiones(Id);
    //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
    //disp.setD1(num-1);
    //dao.edit(disp);
    //}
    public void comandoExitoso() {
        //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
        //disp.setEstado(1);
        //dao.edit(disp);
    }

    public void comandoEnEspera() {
        //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
        //disp.setEstado(2);
        //dao.edit(disp);
    }

    public void comandoFallo() {
        //disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
        //disp.setEstado(3);
        //dao.edit(disp);
    }

    //public int numeroConexiones(int ID){
    //disp = (Dispositivo) dao.findObject(new Long(String.valueOf(ID)), new Dispositivo());
    //    int c = disp.getD1();
    //    return c;
    //}
    public int obtenerEstadoComando() {
//        disp = (Dispositivo) dao.findObject(IdDispositivo, new Dispositivo());
//        int e = disp.getEstado();
        return 0;
    }

    public float byteArrayToFloat(byte aBytes[], int NullC) {
        if (aBytes[0] == NullC) {// el null code de las demas funciones es diferente a la de la funcion 6 que es FE y no FF
            aBytes[0] = 0;
        }
        if (aBytes[1] == NullC) {
            aBytes[1] = 0;
        }
        if (aBytes[2] == NullC) {
            aBytes[2] = 0;
        }
        if (aBytes[3] == NullC) {
            aBytes[3] = 0;
        }
        int tempbits = ((0xff & aBytes[1]) | ((0xff & aBytes[0]) << 8) | ((0xff & aBytes[3]) << 16) | ((0xff & aBytes[2]) << 24));
        float ff = Float.intBitsToFloat(tempbits);
        return ff;
    }

    public int byteArrayToInt(byte[] b, byte NullC) {
        if (b[0] == NullC) {
            b[0] = 0;
        }
        if (b[1] == NullC) {
            b[1] = 0;
        }
        int msb = (int) b[0];
        if (msb < 0) {
            msb = msb + 256;
        }
        int lsb = (int) b[1];
        if (lsb < 0) {
            lsb = lsb + 256;
        }
        int resultado;

        int m1 = msb / 16;
        int m0 = msb % 16;
        resultado = m0 * 256 + m1 * 4096 + lsb;
        if (resultado > 32766) {
            resultado = resultado - 65536;
        }
        return resultado;
    }

    public byte[] shortToByteArray(int e) {
        if (e < 0) {
            e = e + 65536;
        }
        byte[] b = new byte[2];
        int msb1;
        int msb0;
        int lsb1;
        int lsb0;
        lsb0 = e % 16;
        if (e / 16 >= 16) {
            e = e / 16;
            lsb1 = e % 16;
            if (e / 16 >= 0) {
                e = e / 16;
                msb0 = e % 16;
                msb1 = e / 16;
            } else {
                msb0 = e / 16;
                msb1 = 0;
            }
        } else {
            lsb1 = e / 16;
            msb0 = 0;
            msb1 = 0;
        }
        b[1] = (byte) (lsb0 + lsb1 * 16);
        b[0] = (byte) (msb0 + msb1 * 16);
        return b;
    }

    public byte[] floatToByteArray(float f) {

        int i = Float.floatToRawIntBits(f);
        byte[] numero = new byte[4];
        byte aux[] = new byte[4];
        numero = intToByteArray(i);
        aux[0] = numero[0];
        aux[1] = numero[1];
        aux[2] = numero[2];
        aux[3] = numero[3];
        numero[0] = aux[2];
        numero[1] = aux[3];
        numero[2] = aux[0];
        numero[3] = aux[1];
        return numero;
    }

    public byte[] intToByteArray(int param) {
        byte[] result = new byte[4];
        for (int i = 0; i < 4; i++) {

            int offset = (result.length - 1 - i) * 8;
            result[i] = (byte) ((param >>> offset) & MASK);
        }
        return result;
    }

    public int ByteToBoolean(byte b, byte NullC) {
        if (b == NullC) {
            return 0;
        } else {
            return 1;
        }
    }

    public byte IntToByte(int b, byte NullC) {
        if (b == 1) {
            return 1;
        } else {
            return NullC;
        }
    }

    public void close() {
        dao.cerrarConexionBD();
    }
}
